Almost every device today has embedded software inside. Such firmware provides almost all necessary functionality. Because firmware can be changed, bugs and limitations can be addressed and new features can be added without having to replace hardware. Firmware updates can be made in various ways, for example by having a user provide an update to the device by inserting a USB storage device. Updates can be provided in the form of a complete replacement firmware or in the form of limited changes to particular aspects of the firmware, for example replacing a single file or a certain number of bytes in the firmware.
In client-server configurations, such as television set-top boxes connected to a central server, firmware updates on the clients can be managed centrally. The server can transmit firmware updates to each client system, avoiding the user the hassle of having to do so manually. The server can keep track of which previous updates have been provided where, to ensure each client system receives the right new updates.
One important aspect of firmware is its performance. Firmware runs in a constrained environment; typically the hardware platform has limited memory, storage and/or processing capacity compared to general purpose computing platforms such as desktop computers or laptops. Thus, optimizing the firmware for the best performance in such a constrained environment is an important technical problem.
One known manner of addressing this problem is to employ statistics on the usage of certain software functions in the firmware in a predetermined time period. These statistics allow the identification of more and less relevant functions. For example, statistics can reveal that a particular function is used very frequently or that a particular function is often invoked together with another function.
These statistics may differ from user to user. For example, one user may often watch TV channels using the Electronic Program Guide (EPG) on the set-top box to select them, while another may prefer to use the box to play games or browse the Internet. These users would have very different function usage statistics. In addition, statistics may change from time to time, both in the short term and in the long term. In the short term, e.g. over a couple of days, usage may change e.g. from incidental watching of short programs during the work week to more intensive use in the weekend. In the long term, usage may change e.g. from passively watching children's shows to actively using games and interactive features.
Given these statistics it becomes possible to identify functions that are more relevant than others and to issue updates to the firmware addressing those functions to improve the functioning of the firmware. For example, a frequently-used function can be optimized to run faster, or provided with a pre-loading or caching feature. A function that is not used frequently anymore could have such features removed, or be moved to a separately-loadable module to make memory available for more frequently used functions. Two functions often used together could be integrated into a single module.
In some applications, it is desirable to issue very frequent updates, e.g. every few days, containing relatively small changes. This requires a constant delivery of function usage statistics. This could be a problem, as the return channel from client to server system is typically low-bandwidth. The statistics thus would not arrive in time, or only limited statistics could be provided. Therefore a technical problem is how to reduce the amount of data in the function usage statistics without loss of information.